var itemId = 0;
var personBaseMax;
var personBaseMin;
var companyBaseMax;
var companyBaseMin;
var personPercentMax;
var personPercentMin;
var companyPercentMax;
var companyPercentMin;
var socialTypeMasterStore;
function checkDate(strDate, rowIndex, colIndex) {
	if (strDate == '' || strDate == null) {
		Ext.MessageBox.alert('Error', '请输入日期！', function() {
					Ext.getCmp('TGride').startEditing(rowIndex, colIndex);
				});
		return false;
	}
	var reg = /^(\d{4})(\d{2})$/;
	if (!reg.test(strDate)) {
		Ext.MessageBox.alert('Error', '日期格式不正确!\n正确格式为:yyyyMM！', function() {
					Ext.getCmp('TGride').startEditing(rowIndex, colIndex);
				});
		return false;
	}
	var year = strDate.substring(4, 0);
	var month = strDate.substring(4);
	if (!checkMonth(month, rowIndex, colIndex)) {
		return false;
	}
	return true;
}
function checkMonth(month, rowIndex, colIndex) {
	if (isNaN(parseInt(month, 10))) {
		Ext.MessageBox.alert('Error', '月份输入有误,请重新输入！', function() {
					Ext.getCmp('TGride').startEditing(rowIndex, colIndex);
				});
		return false;
	} else if (parseInt(month, 10) < 1 || parseInt(month, 10) > 12) {
		Ext.MessageBox.alert('Error', '月份应该在1-12之间！', function() {
					Ext.getCmp('TGride').startEditing(rowIndex, colIndex);
				});
		return false;
	} else
		return true;
}
function fn_setBackValues() {
	personBaseMax = socialTypeMasterStore.getById(itemId).get("personBaseMax");
	personBaseMin = socialTypeMasterStore.getById(itemId).get("personBaseMin");
	companyBaseMax = socialTypeMasterStore.getById(itemId)
			.get("companyBaseMax");
	companyBaseMin = socialTypeMasterStore.getById(itemId)
			.get("companyBaseMin");
	personPercentMax = socialTypeMasterStore.getById(itemId)
			.get("personPercentMax");
	personPercentMin = socialTypeMasterStore.getById(itemId)
			.get("personPercentMin");
	companyPercentMax = socialTypeMasterStore.getById(itemId)
			.get("companyPercentMax");
	companyPercentMin = socialTypeMasterStore.getById(itemId)
			.get("companyPercentMin");
}
function fn_gridTextReset() {
	$("employee_id_new").value = "";
	$("empname_new").value = "";
	$("empid_new").value = "";
}
function fn_checkForm(flag) {
	var after_person_default = "after_person_default" + flag;
	var after_person_percent = "after_person_percent" + flag;
	var after_company_default = "after_company_default" + flag;
	var after_company_percent = "after_company_percent" + flag;
	var person_value = $F(after_person_default), person_percent = $F(after_person_percent), company_value = $F(after_company_default), company_percent = $F(after_company_percent);
	if (person_value != ""
			&& (person_value > personBaseMax || person_value < personBaseMin)) {
		alert("调整后的个人基数必须在 " + personBaseMin + "至" + personBaseMax + " 范围之内！");
		Ext.getCmp(after_person_default).selectText(0, 100);
		return false;
	}
	if (person_percent != ""
			&& (person_percent > companyPercentMax || person_percent < companyPercentMin)) {
		alert("调整后的个人比例必须在 " + companyPercentMin + "至" + companyPercentMax
				+ " 范围之内！");
		Ext.getCmp(after_person_percent).selectText(0, 100);
		return false;
	}
	if (company_value != ""
			&& (company_value > companyBaseMax || company_value < companyBaseMin)) {
		alert("调整后的企业基数必须在 " + companyBaseMin + "至" + companyBaseMax + " 范围之内！");
		Ext.getCmp(after_company_default).selectText(0, 100);
		return false;
	}
	if (company_percent != ""
			&& (company_percent > companyPercentMax || company_percent < companyPercentMin)) {
		alert("调整后的企业比例必须在 " + companyPercentMin + "至" + companyPercentMax
				+ " 范围之内！");
		Ext.getCmp(after_company_percent).selectText(0, 100);
		return false;
	}
	if (person_value == person_percent && person_percent == company_value
			&& company_value == company_percent) {
		Ext.Msg.alert("警告", "个人、企业的比例基数四项至少需要填写一项！");
		return false;
	}
	if (flag != 2) {
		if (fn_empGridPanel().getSelectionModel().getSelections().length == 0) {
			Ext.Msg.alert("警告", "请勾选需要调整社保的员工！");
			return false;
		}
	} else {
		if (fn_empGridPanel().getStore().getCount() == 0) {
			Ext.Msg.alert("警告", "您没有选择员工，请确认！");
			return false;
		}
	}
	return true;
}
Ext.onReady(function() {
	var socialtype = '';
	var deletedJson = [];
	var updflag;
	function fn_addItem(iGrid, selectRecords, iWindow) {
		var recordLength = selectRecords.length;
		var add = 0, ducp = 0;
		var ss = [];
		var add_data = [], ducp_data = [];
		// var selectRecords = iGrid.getSelectionModel().getSelections();//选好记录
		var selectLength = selectRecords.length;// 选好记录长度
		for (var j = 0; j < selectLength; j++) {
			var index = newstore.find('social_security_id',
					selectRecords[j].data.social_security_id);
			if (index == -1) {
				ss.push(selectRecords[j]);
				add_data.push(selectRecords[j].data.show_name);
				add++;
			} else {
				ducp_data.push(selectRecords[j].data.show_name);
				ducp++;
			}
		};
		if (add == 0) {
			Ext.Msg.alert('警告', '您要添加的社保项目已经存在，请重新选择！');
			return;
		} else if (ducp != 0) {
			Ext.MessageBox.confirm('确认添加', '您要添加的' + recordLength + '条社保项目有'
							+ ducp + '条已经存在，是否把未重复的' + add
							+ '条添加进去？\n重复的社保项目名称为：\"' + ducp_data.join(",")
							+ '\"。', function(btn) {
						if (btn == "yes") {
							for (var i = 0; i < ss.length; i++) {
								newstore.add(ss[i]);
							}
							iGrid.getStore().removeAll();
							iWindow.hide();
						}
					});
		} else {
			Ext.MessageBox.confirm('确认添加', '请确认要添加' + add + '条社保项目？', function(
							btn) {
						if (btn == "yes") {
							for (var i = 0; i < ss.length; i++) {
								newstore.add(ss[i]);
							}
							iGrid.getStore().removeAll();
							iWindow.hide();
						}
					});
		}
	}
	// 社保调整-----------------------------------------------------------------------------------------------------
	// 社保项目数据源start-----------------------------------
	socialTypeMasterStore = new Ext.data.Store({
				url : 'socialItem!findSocialItemByCompanCode.action',
				reader : new Ext.data.JsonReader({
							root : 'beanList',
							id : 'socialItemId'
						}, [{
									name : 'social_security_id',
									mapping : 'socialItemId'
								}, {
									name : 'show_name',
									mapping : 'socialItemName'
								}, {
									name : 'personBaseMax',
									mapping : 'personBaseMax'
								}, {
									name : 'personBaseMin',
									mapping : 'personBaseMin'
								}, {
									name : 'companyBaseMax',
									mapping : 'companyBaseMax'
								}, {
									name : 'companyBaseMin',
									mapping : 'companyBaseMin'
								}, {
									name : 'personPercentMax',
									mapping : 'personPercentMax'
								}, {
									name : 'personPercentMin',
									mapping : 'personPercentMin'
								}, {
									name : 'companyPercentMax',
									mapping : 'companyPercentMax'
								}, {
									name : 'companyPercentMin',
									mapping : 'companyPercentMin'
								}])
			});

	// 社保项目数据源end-----------------------------------
	// 调整items
	var adjustForm_up = new Ext.form.FormPanel({
		frame : true,
		region : 'north',
		id : 'adjustForm_up',
		height : 40,
		bodyStyle : 'padding:5px 5px 0',
		items : [{
			layout : 'column',
			items : [{
				columnWidth : 1,
				layout : 'form',
				buttonAlign : 'left',
				items : [{
					xtype : 'combo',
					store : socialTypeMasterStore,
					valueField : "social_security_id",
					displayField : "show_name",
					fieldLabel : '社保项目名称',
					hideName : 'SHOW_NAME1',
					name : 'SHOW_NAME1',
					id : 'SHOW_NAME1',
					anchor : '90%',
					allowBlank : false,
					blankText : '社保项目名称不能为空',
					emptyText : '请选择社保项目名称',
					triggerAction : 'all',
					editable : false,
					listeners : {
						select : function(combo, record, index) {
							itemId = this.getValue();
							fn_setBackValues();
							temp_store = fn_empGridPanel().getStore();
							temp_store.on('beforeload', function() {
										temp_store.baseParams = {
											'filter.socialItemId' : itemId
										}
									});
							temp_store.proxy = new Ext.data.HttpProxy({
								url : 'CsEmplsocialAction!queryEmpBySocialItem.action'
							});
							temp_store.load();
						}
					}
				}]
			}]
		}]
	});
	var adjustForm_down = new Ext.form.FormPanel({
		frame : true,
		region : 'south',
		id : 'adjustForm_down',
		height : 70,
		bodyStyle : 'padding:5px 5px 0',
		items : [{
			layout : 'column',
			items : [{
						columnWidth : .5,
						layout : 'form',
						items : [{
									xtype : 'numberfield',
									fieldLabel : '调整后个人基数',
									name : 'csEmplsocial.person_base_default',
									id : 'after_person_default',
									anchor : '90%',
									allowBlank : true,
									emptyText : ''
								}, {
									xtype : 'numberfield',
									fieldLabel : '调整后个人比例',
									name : 'csEmplsocial.person_percent_default',
									id : 'after_person_percent',
									anchor : '90%',
									allowBlank : true,
									emptyText : ''
								}]
					}, {
						columnWidth : .5,
						layout : 'form',
						items : [{
									xtype : 'numberfield',
									fieldLabel : '调整后企业基数',
									name : 'csEmplsocial.company_base_default',
									id : 'after_company_default',
									anchor : '90%',
									allowBlank : true,
									emptyText : ''
								}, {
									xtype : 'numberfield',
									fieldLabel : '调整后企业比例',
									name : 'csEmplsocial.company_percent_default',
									id : 'after_company_percent',
									anchor : '90%',
									allowBlank : true,
									emptyText : ''
								}]
					}]
		}]
	});
	var adjustForm2_down = new Ext.form.FormPanel({
		frame : true,
		region : 'south',
		id : 'adjustForm2_down',
		height : 100,
		bodyStyle : 'padding:5px 5px 0',
		items : [{
			layout : 'column',
			items : [{
						columnWidth : 1,
						layout : 'form',
						buttonAlign : 'left',
						items : [{
									xtype : 'combo',
									store : socialTypeMasterStore,
									valueField : "social_security_id",
									displayField : "show_name",
									fieldLabel : '社保项目名称',
									hideName : 'SHOW_NAME2',
									name : 'SHOW_NAME2',
									id : 'SHOW_NAME2',
									anchor : '90%',
									allowBlank : false,
									blankText : '社保项目名称不能为空',
									emptyText : '请选择社保项目名称',
									triggerAction : 'all',
									editable : false,
									listeners : {
										select : function(combo, record, index) {
											itemId = this.getValue();
											fn_setBackValues();
										}
									}
								}]
					}]
		}, {
			layout : 'column',
			items : [{
						columnWidth : .5,
						layout : 'form',
						items : [{
									xtype : 'numberfield',
									fieldLabel : '调整后个人基数',
									name : 'csEmplsocial.person_base_default',
									id : 'after_person_default2',
									anchor : '90%',
									allowBlank : true,
									emptyText : ''
								}, {
									xtype : 'numberfield',
									fieldLabel : '调整后个人比例',
									name : 'csEmplsocial.person_percent_default',
									id : 'after_person_percent2',
									anchor : '90%',
									allowBlank : true,
									emptyText : ''
								}]
					}, {
						columnWidth : .5,
						layout : 'form',
						items : [{
									xtype : 'numberfield',
									fieldLabel : '调整后企业基数',
									name : 'csEmplsocial.company_base_default',
									id : 'after_company_default2',
									anchor : '90%',
									allowBlank : true,
									emptyText : ''
								}, {
									xtype : 'numberfield',
									fieldLabel : '调整后企业比例',
									name : 'csEmplsocial.company_percent_default',
									id : 'after_company_percent2',
									anchor : '90%',
									allowBlank : true,
									emptyText : ''
								}]
					}]
		}]
	});
	// 调整社保窗口
	var adjustWindow = new Ext.Window({
		modal : true,
		layout : 'border',
		x : 100,
		y : 100,
		width : 450,
		height : 500,
		title : '按项目调整社保档案',
		collapsible : false,
		minimizable : false,
		maximizable : false,
		resizable : false,
		constrain : true,
		plain : true,
		bufferResize : true,
		autoDestroy : 'hide',
		closeAction : 'hide',
		listeners : {
			"beforedestroy" : function(obj) {
				Ext.getCmp('SHOW_NAME1').reset();
				adjustForm_down.getForm().reset();
				fn_empGridPanel().getStore().removeAll();
				return true;
			},
			"beforeshow" : function(obj) {
				Ext.getCmp('SHOW_NAME1').reset();
				adjustForm_down.getForm().reset();
				fn_empGridPanel().getStore().removeAll();
				return true;
			},
			"beforehide" : function(obj) {
				Ext.getCmp('SHOW_NAME1').reset();
				adjustForm_down.getForm().reset();
				fn_empGridPanel().getStore().removeAll();
				return true;
			}
		},
		items : [adjustForm_up, fn_empGridPanel(), adjustForm_down],
		buttons : [{
			text : '确认调整',
			id : 'save',
			handler : function() {
				if (Ext.getCmp('adjustForm_down').getForm().isValid()) {
					if (fn_checkForm("")) {
						var ids = [];
						var records = fn_empGridPanel().getSelectionModel()
								.getSelections();
						for (var i = 0; i < records.length; i++) {
							ids.push(records[i].data.employee_id);
						}
						Ext.Ajax.request({
							url : "CsEmplsocialAction!adjustSocial.action",
							method : 'post',
							params : {
								'csEmplsocial.ids' : ids.join(','),
								'csEmplsocial.social_security_id' : $F('SHOW_NAME1'),
								'csEmplsocial.person_base_default' : $F("after_person_default"),
								'csEmplsocial.person_percent_default' : $F("after_person_percent"),
								'csEmplsocial.company_base_default' : $F("after_company_default"),
								'csEmplsocial.company_percent_default' : $F("after_company_percent")
							},
							success : function() {
								Ext.Msg.show({
											title : '操作信息',
											msg : '社保调整成功！',
											buttons : Ext.Msg.OK
										});
								adjustWindow.hide();
							},
							failure : function() {
								adjustWindow.hide();
								Ext.Msg.show({
											title : '操作信息',
											msg : '社保调整异常，请联系管理员！',
											buttons : Ext.Msg.OK
										});
							}
						});
					}
				} else {
					Ext.Msg.alert("警告", "请确认信息是否填写完整！");
				}
			}
		}, {
			text : '取消',
			id : 'cancel',
			handler : function() {
				adjustWindow.hide();
			}
		}]
	});
	var adjustWindow2 = new Ext.Window({
		modal : true,
		id : 'adjustWindow2',
		layout : 'border',
		x : 100,
		y : 100,
		width : 450,
		height : 500,
		title : '按员工调整社保档案',
		collapsible : false,
		minimizable : false,
		maximizable : false,
		resizable : false,
		constrain : true,
		plain : true,
		bufferResize : true,
		autoDestroy : 'hide',
		closeAction : 'hide',
		listeners : {
			"beforedestroy" : function(obj) {
				adjustForm2_down.getForm().reset();
				fn_empGridPanel().getStore().removeAll();
				return true;
			},
			"beforeshow" : function(obj) {
				adjustForm2_down.getForm().reset();
				fn_empGridPanel().getStore().removeAll();
				return true;
			},
			"beforehide" : function(obj) {
				adjustForm2_down.getForm().reset();
				fn_empGridPanel().getStore().removeAll();
				return true;
			}
		},
		items : [fn_empGridPanel(), adjustForm2_down],
		buttons : [{
			text : '确认调整',
			id : 'save',
			handler : function() {
				if (Ext.getCmp('adjustForm2_down').getForm().isValid()) {
					if (fn_checkForm("2")) {
						var ids = [];
						for (var i = 0; i < existEmpStore.getCount(); i++) {
							ids.push(existEmpStore.getAt(i).data.employee_id);
						}
						Ext.Ajax.request({
							url : "CsEmplsocialAction!adjustSocial.action",
							method : 'post',
							params : {
								'csEmplsocial.ids' : ids.join(','),
								'csEmplsocial.social_security_id' : $F('SHOW_NAME2'),
								'csEmplsocial.person_base_default' : $F("after_person_default2"),
								'csEmplsocial.person_percent_default' : $F("after_person_percent2"),
								'csEmplsocial.company_base_default' : $F("after_company_default2"),
								'csEmplsocial.company_percent_default' : $F("after_company_percent2")
							},
							success : function() {
								Ext.Msg.show({
											title : '操作信息',
											msg : '社保调整成功！',
											buttons : Ext.Msg.OK
										});
								adjustWindow2.hide();
							},
							failure : function() {
								adjustWindow2.hide();
								Ext.Msg.show({
											title : '操作信息',
											msg : '社保调整异常，请联系管理员！',
											buttons : Ext.Msg.OK
										});
							}
						});
					}
				} else {
					Ext.Msg.alert("警告", "请确认信息是否填写完整！");
				}
			}
		}, {
			text : '取消',
			id : 'cancel',
			handler : function() {
				adjustWindow2.hide();
			}
		}]
	});
	// 社保调整end---------------------------------------------------------------

	// 未社保员工-------------------------------------------------------------------------------------------------------------------
	var empsm = new Ext.grid.CheckboxSelectionModel();
	var empcm = new Ext.grid.ColumnModel([new Ext.grid.RowNumberer(), empsm, {
				header : '员工标识',
				width : 90,
				hidden : true,
				dataIndex : 'employee_id'
			}, {
				header : '员工编号',
				width : 90,
				dataIndex : 'emp_cs_code'
			}, {
				header : '员工姓名',
				width : 90,
				dataIndex : 'name'
			}]);
	var empstore = new Ext.data.Store({
				url : 'CsEmplsocialAction!queryCsEmployeeResult.action',
				reader : new Ext.data.JsonReader({
							root : 'pbEmployeeResult.result',
							id : 'employee_id',
							totalProperty : 'pbEmployeeResult.totalCount'
						}, [{
									name : 'employee_id',
									mapping : 'employee_id'
								}, {
									name : 'emp_cs_code',
									mapping : 'emp_cs_code'
								}, {
									name : 'name',
									mapping : 'name'
								}])
			});

	var empGrid = new Ext.grid.GridPanel({
		autoScroll : true,
		id : 'EGride',
		region : 'center',
		tbar : ['员工编号:', {
					xtype : 'textfield',
					id : 'empid_new1'
				}, {
					xtype : "tbseparator"
				}, '员工姓名:', {
					xtype : 'textfield',
					id : 'empname_new1'
				}, {
					xtype : "tbseparator"
				}, {
					xtype : 'button',
					text : '员工查询',
					handler : function() {
						empstore.on('beforeload', function() {
							empstore.baseParams = {
								'pbEmployeeFilter.empCsCode' : $F('empid_new1'),
								'pbEmployeeFilter.name' : $F('empname_new1')
							}
						});
						empstore.load();
					}
				}],
		bbar : new Ext.PagingToolbar({
					pageSize : pageSize,
					store : empstore,
					displayInfo : true,
					dispalyMsg : '显示第{0}条到{1}条记录，一共{2}条',
					emptyMsg : '没有记录'
				}),
		cm : empcm,
		selModel : new Ext.grid.RowSelectionModel({
					singleSelect : true
				}),
		store : empstore,
		loadMask : true,
		loadMask : {
			msg : '正在加载数据...'
		}
	});
	empGrid.addListener('rowdblclick', rowdblclickFn1);
	function rowdblclickFn1(grid, rowIndex, e) {
		var length = empGrid.getSelectionModel().getSelections().length;
		if (length < 1) {
			return;
		} else {
			Ext.getCmp('employee_id_new').setValue(empGrid.getSelectionModel()
					.getSelections()[0].get('employee_id'));
			Ext.getCmp('empid_new').setValue(empGrid.getSelectionModel()
					.getSelections()[0].get('emp_cs_code'));
			Ext.getCmp('empname_new').setValue(empGrid.getSelectionModel()
					.getSelections()[0].get('name'));
		}
		empWindow.hide();
	}
	var empWindow = new Ext.Window({
		layout : 'border',
		x : 200,
		y : 200,
		width : 500,
		height : 450,
		title : '员工查询',
		collapsible : true,
		minimizable : true,
		maximizable : true,
		constrain : true,
		plain : true,
		bufferResize : true,
		autoDestroy : 'hide',
		closeAction : 'hide',
		listeners : {
			minimize : function(w) {
				w.setPosition(0, 0);
				w.setSize(500, 400);
			}
		},
		items : [empGrid],
		buttons : [{
			text : '确定',
			id : 'save',
			handler : function() {
				var length = empGrid.getSelectionModel().getSelections().length;
				if (length < 1) {
					return;
				} else {
					Ext.getCmp('employee_id_new').setValue(empGrid
							.getSelectionModel().getSelections()[0]
							.get('employee_id'));
					Ext.getCmp('empid_new').setValue(empGrid
							.getSelectionModel().getSelections()[0]
							.get('emp_cs_code'));
					Ext.getCmp('empname_new')
							.setValue(empGrid.getSelectionModel()
									.getSelections()[0].get('name'));
				}
				empWindow.hide();
			}
		}, {
			text : '取消',
			id : 'cancel',
			handler : function() {
				empWindow.hide();
			}
		}]
	});
	// 增加细项--------------------------------------------------------------------------------------------------------------
	var ism = new Ext.grid.CheckboxSelectionModel();
	var icm = new Ext.grid.ColumnModel([new Ext.grid.RowNumberer(), ism, {
				header : '标识',
				width : 90,
				hidden : true,
				dataIndex : 'sub_social_security_id'
			}, {
				header : '社保项目标识',
				width : 90,
				hidden : true,
				dataIndex : 'social_security_id'
			}, {
				header : '所属类别标识',
				width : 90,
				hidden : true,
				dataIndex : 'social_typeid'
			}, {
				header : '社保项目名称',
				width : 90,
				dataIndex : 'show_name'
			}, {
				header : '所属类别',
				width : 90,
				dataIndex : 'social_typename'
			}, {
				header : '个人基数',
				width : 90,
				dataIndex : 'person_base_default'
			}, {
				header : '个人比例',
				width : 90,
				dataIndex : 'person_percent_default'
			}, {
				header : '企业基数',
				width : 90,
				dataIndex : 'company_base_default'
			}, {
				header : '企业比例',
				width : 90,
				dataIndex : 'company_percent_default'
			}, {
				header : '个人附加金额',
				width : 90,
				dataIndex : 'person_add'
			}, {
				header : '企业附加金额',
				width : 90,
				dataIndex : 'company_add'
			}]);
	var istore = new Ext.data.Store({
				url : 'CsEmplsocialAction!queryPbSocialItemsResult.action',
				reader : new Ext.data.JsonReader({
							root : 'csSocialResult.result',
							id : 'sub_social_security_id',
							totalProperty : 'csSocialResult.totalCount'
						}, [{
									name : 'employee_ss_id',
									mapping : 'employee_ss_id'
								}, {
									name : 'sub_social_security_id',
									mapping : 'sub_social_security_id'
								}, {
									name : 'social_security_id',
									mapping : 'social_security_id'
								}, {
									name : 'social_typeid',
									mapping : 'social_typeid'
								}, {
									name : 'show_name',
									mapping : 'show_name'
								}, {
									name : 'social_typename',
									mapping : 'social_typename'
								}, {
									name : 'start_month',
									mapping : 'start_month'
								}, {
									name : 'end_month',
									mapping : 'end_month'
								}, {
									name : 'add_start_month',
									mapping : 'add_start_month'
								}, {
									name : 'add_end_month',
									mapping : 'add_end_month'
								}, {
									name : 'add_pay_month',
									mapping : 'add_pay_month'
								}, {
									name : 'person_base_default',
									mapping : 'person_base_default'
								}, {
									name : 'person_percent_default',
									mapping : 'person_percent_default'
								}, {
									name : 'company_base_default',
									mapping : 'company_base_default'
								}, {
									name : 'company_percent_default',
									mapping : 'company_percent_default'
								}, {
									name : 'person_add',
									mapping : 'person_add'
								}, {
									name : 'company_add',
									mapping : 'company_add'
								}])
			});
	function getProvinceStore() {
		var provinceStore = new Ext.data.Store({
					proxy : new Ext.data.HttpProxy({
								url : 'Province!queryProvinceList.action'
							}),
					reader : new Ext.data.JsonReader({
								root : 'resultL',
								id : 'id'
							}, [{
										name : 'province_id',
										mapping : 'province_id'
									}, {
										name : 'province_name',
										mapping : 'province_name'
									}])
				});
		provinceStore.load();
		return provinceStore;
	}
	function getCityStore() {
		var cityStore = new Ext.data.Store({
					proxy : new Ext.data.HttpProxy({
								url : 'City!queryCityByProviceId.action?province_id='
							}),
					reader : new Ext.data.JsonReader({
								root : 'resultCity',
								id : 'id'
							}, [{
										name : 'CITY_ID',
										mapping : 'CITY_ID'
									}, {
										name : 'CITY_NAME',
										mapping : 'CITY_NAME'
									}])

				});
		return cityStore;
	}
	// 城市的下拉框
	var cityCombox1 = new Ext.form.ComboBox({
				fieldLabel : '城市',
				name : 'city_id1',
				// hiddenName : 'city_id1',
				id : 'city_id1',
				store : getCityStore(),
				displayField : 'CITY_NAME',
				valueField : 'CITY_ID',
				typeAhead : true,
				mode : 'remote',
				triggerAction : 'all',
				selectOnFocus : true,
				anchor : '90%',
				forceSelection : true,
				emptyText : '请选择...',
				width : 150
			});
	// 省份的下拉框
	var proviceCombox1 = new Ext.form.ComboBox({
		fieldLabel : '省份',
		name : 'province_id1',
		// hiddenName : 'province_id1',
		id : 'province_id1',
		store : getProvinceStore(),
		displayField : 'province_name',
		valueField : 'province_id',
		typeAhead : true,
		mode : 'remote',
		triggerAction : 'all',
		selectOnFocus : true,
		anchor : '90%',
		forceSelection : true,
		emptyText : '请选择...',
		width : 150,
		listeners : {
			select : function(combo, record, index) {
				cityStore = cityCombox1.getStore();
				cityStore.proxy = new Ext.data.HttpProxy({
							url : 'City!queryCityByProviceId.action?province_id='
									+ proviceCombox1.getValue()
						});

				cityStore.load();
			}
		}
	});
	function getSocialType() {
		var socialTypeStore = new Ext.data.Store({
					proxy : new Ext.data.HttpProxy({
								url : 'socialType!QueryPbSocialType.action'
							}),
					reader : new Ext.data.JsonReader({
								root : 'resultAll',
								id : 'social_typeid'
							}, [{
										name : 'social_typeid',
										mapping : 'social_typeid'
									}, {
										name : 'social_typename',
										mapping : 'social_typename'
									}])
				});
		socialTypeStore.load();
		return socialTypeStore;
	}
	var socialTypeCombox = new Ext.form.ComboBox({
				fieldLabel : '所属类别',
				name : 'social_type',
				id : 'social_type',
				store : getSocialType(),
				displayField : 'social_typename',
				typeAhead : true,
				valueField : 'social_typeid',
				mode : 'local',
				triggerAction : 'all',
				selectOnFocus : true,
				anchor : '90%',
				forceSelection : true,
				width : 150
			});
	var iGrid = new Ext.grid.GridPanel({
				autoScroll : true,
				id : 'IGride',
				region : 'center',
				height : 200,
				tbar : ['省：', proviceCombox1, {
							xtype : "tbseparator"
						}, '市：', cityCombox1, {
							xtype : "tbseparator"
						}, '所属类型：', socialTypeCombox, {
							xtype : "tbseparator"
						}, '社保项目名称:', {
							xtype : 'textfield',
							id : 'iname'
						}, {
							xtype : "tbseparator"
						}, {
							xtype : 'button',
							text : '社保项目查询',
							handler : function() {
								istore.on('beforeload', function() {
											istore.baseParams = {
												'filter.province_id' : Ext
														.getCmp('province_id1')
														.getValue(),
												'filter.city_id' : Ext
														.getCmp('city_id1')
														.getValue(),
												'filter.social_typeid' : Ext
														.getCmp('social_type')
														.getValue(),
												'filter.show_name' : Ext
														.getCmp('iname')
														.getValue()
											}
										});
								istore.load();
							}
						}],
				bbar : new Ext.PagingToolbar({
							pageSize : pageSize,
							store : istore,
							displayInfo : true,
							dispalyMsg : '显示第{0}条到{1}条记录，一共{2}条',
							emptyMsg : '没有记录'
						}),
				sm : ism,
				cm : icm,
				store : istore,
				loadMask : true,
				loadMask : {
					msg : '正在加载数据...'
				}
			});
	// 增加细项页面-------------------------------------------------------------------------------------------------------------------------------
	var iWindow = new Ext.Window({
		layout : 'border',
		x : 150,
		y : 150,
		width : 900,
		height : 400,
		title : '增加细项查询',
		collapsible : true,
		minimizable : true,
		maximizable : true,
		constrain : true,
		plain : true,
		bufferResize : true,
		autoDestroy : 'hide',
		closeAction : 'hide',
		listeners : {
			minimize : function(w) {
				w.setPosition(0, 0);
				w.setSize(500, 400);
			}
		},
		items : [iGrid],
		buttons : [{
			text : '确定',
			id : 'save',
			handler : function() {
				var recordLength = iGrid.getSelectionModel().getSelections().length;
				if (recordLength < 1) {
					return;
				} else {
					fn_addItem(iGrid,
							iGrid.getSelectionModel().getSelections(), iWindow);
				}
			}
		}, {
			text : '取消',
			id : 'cancel',
			handler : function() {
				iWindow.hide();
			}
		}]
	});
	// 推荐模板--------------------------------------------------------------------------------------------------------------
	var dtsm = new Ext.grid.CheckboxSelectionModel();
	var dtcm = new Ext.grid.ColumnModel([new Ext.grid.RowNumberer(), dtsm, {
				header : '模板标识',
				width : 90,
				hidden : true,
				dataIndex : 'template_id'
			}/*
				 * ,{ header : '省标识', width : 90, dataIndex : 'province_id' },{
				 * header : '市标识', width : 90, dataIndex : 'city_id' }
				 */, {
				header : '省',
				width : 90,
				dataIndex : 'province_name'
			}, {
				header : '市',
				width : 90,
				dataIndex : 'city_name'
			}, {
				header : '模板名称',
				width : 90,
				dataIndex : 'name'
			}, {
				header : '项数',
				width : 90,
				dataIndex : 'templateCount'
			}]);
	var dtstore = new Ext.data.Store({
				url : 'CsEmplsocialAction!queryPbsocialTemplateResult.action',
				reader : new Ext.data.JsonReader({
							root : 'csSocialResult.result',
							id : 'social_security_id',
							totalProperty : 'csSocialResult.totalCount'
						}, [{
									name : 'template_id',
									mapping : 'template_id'
								}, {
									name : 'province_id',
									mapping : 'province_id'
								}, {
									name : 'city_id',
									mapping : 'city_id'
								}, {
									name : 'name',
									mapping : 'name'
								}, {
									name : 'province_name',
									mapping : 'province_name'
								}, {
									name : 'city_name',
									mapping : 'city_name'
								}, {
									name : 'templateCount',
									mapping : 'templateCount'
								}])
			});
	function getProvinceStore() {
		var provinceStore = new Ext.data.Store({
					proxy : new Ext.data.HttpProxy({
								url : 'Province!queryProvinceList.action'
							}),
					reader : new Ext.data.JsonReader({
								root : 'resultL',
								id : 'province_id'
							}, [{
										name : 'province_id',
										mapping : 'province_id'
									}, {
										name : 'province_name',
										mapping : 'province_name'
									}])
				});
		provinceStore.load();
		return provinceStore;
	}

	function getCityStore() {
		var cityStore = new Ext.data.Store({
					proxy : new Ext.data.HttpProxy({
								url : 'City!queryCityByProviceId.action?province_id='
							}),
					reader : new Ext.data.JsonReader({
								root : 'resultCity',
								id : 'CITY_ID'
							}, [{
										name : 'CITY_ID',
										mapping : 'CITY_ID'
									}, {
										name : 'CITY_NAME',
										mapping : 'CITY_NAME'
									}])

				});
		return cityStore;
	}
	// 城市的下拉框
	var cityCombox = new Ext.form.ComboBox({
				fieldLabel : '城市',
				name : 'city_id',
				// hiddenName : 'city_id',
				id : 'city_id',
				store : getCityStore(),
				displayField : 'CITY_NAME',
				valueField : 'CITY_ID',
				typeAhead : true,
				mode : 'remote',
				triggerAction : 'all',
				selectOnFocus : true,
				anchor : '90%',
				forceSelection : true,
				emptyText : '请选择...',
				width : 150
			});
	// 省份的下拉框
	var proviceCombox = new Ext.form.ComboBox({
		fieldLabel : '省份',
		name : 'province_id',
		// hiddenName : 'province_id',
		id : 'province_id',
		store : getProvinceStore(),
		displayField : 'province_name',
		valueField : 'province_id',
		typeAhead : true,
		mode : 'remote',
		triggerAction : 'all',
		selectOnFocus : true,
		anchor : '90%',
		forceSelection : true,
		emptyText : '请选择...',
		width : 150,
		listeners : {
			select : function(combo, record, index) {
				cityStore = cityCombox.getStore();
				cityStore.proxy = new Ext.data.HttpProxy({
							url : 'City!queryCityByProviceId.action?province_id='
									+ proviceCombox.getValue()
						});

				cityStore.load();
			}
		}
	});
	var dtGrid = new Ext.grid.GridPanel({
				autoScroll : true,
				id : 'DTGride',
				region : 'north',
				height : 200,
				tbar : ['省：', proviceCombox, {
							xtype : "tbseparator"
						}, '市：', cityCombox, {
							xtype : "tbseparator"
						}, '模板名称:', {
							xtype : 'textfield',
							id : 'dtname'
						}, {
							xtype : "tbseparator"
						}, {
							xtype : 'button',
							text : '模板查询',
							handler : function() {
								dtstore.on('beforeload', function() {
											dtstore.baseParams = {
												'filter.province_id' : Ext
														.getCmp('province_id')
														.getValue(),
												'filter.city_id' : Ext
														.getCmp('city_id')
														.getValue(),
												'filter.name' : Ext
														.getCmp('dtname')
														.getValue()
											}
										});
								dtstore.load();
							}
						}],
				bbar : new Ext.PagingToolbar({
							pageSize : pageSize,
							store : dtstore,
							displayInfo : true,
							dispalyMsg : '显示第{0}条到{1}条记录，一共{2}条',
							emptyMsg : '没有记录'
						}),
				cm : dtcm,
				selModel : new Ext.grid.RowSelectionModel({
							singleSelect : true
						}),
				store : dtstore,
				loadMask : true,
				loadMask : {
					msg : '正在加载数据...'
				}
			});
	dtGrid.addListener('rowclick', rowdblclickFn3);
	function rowdblclickFn3(grid, rowIndex, e) {
		var length = dtGrid.getSelectionModel().getSelections().length;
		if (length < 1) {
			return;
		} else {
			dtdstore.baseParams = {
				'filter.template_id' : dtGrid.getSelectionModel()
						.getSelections()[0].get('template_id')
			}
			dtdstore.load();
		}
	}
	// 推荐模板细项--------------------------------------------------------------------------------------------------------------------------
	var dtdcm = new Ext.grid.ColumnModel([new Ext.grid.RowNumberer(), {
				header : '标识',
				width : 90,
				hidden : true,
				dataIndex : 'sub_social_security_id'
			}, {
				header : '社保项目标识',
				width : 90,
				hidden : true,
				dataIndex : 'social_security_id'
			}, {
				header : '所属类别标识',
				width : 90,
				hidden : true,
				dataIndex : 'social_typeid'
			}, {
				header : '社保项目名称',
				width : 90,
				dataIndex : 'show_name'
			}, {
				header : '所属类别',
				width : 90,
				dataIndex : 'social_typename'
			}, {
				header : '个人基数',
				width : 90,
				dataIndex : 'person_base_default'
			}, {
				header : '个人比例',
				width : 90,
				dataIndex : 'person_percent_default'
			}, {
				header : '企业基数',
				width : 90,
				dataIndex : 'company_base_default'
			}, {
				header : '企业比例',
				width : 90,
				dataIndex : 'company_percent_default'
			}, {
				header : '个人附加金额',
				width : 90,
				dataIndex : 'person_add'
			}, {
				header : '企业附加金额',
				width : 90,
				dataIndex : 'company_add'
			}]);
	var dtdstore = new Ext.data.Store({
				url : 'CsEmplsocialAction!queryPbsocialTemplateDetailsResult.action',
				reader : new Ext.data.JsonReader({
							root : 'recomSocialList',
							id : 'sub_social_security_id'
						}, [{
									name : 'employee_ss_id',
									mapping : 'employee_ss_id'
								}, {
									name : 'sub_social_security_id',
									mapping : 'sub_social_security_id'
								}, {
									name : 'social_security_id',
									mapping : 'social_security_id'
								}, {
									name : 'social_typeid',
									mapping : 'social_typeid'
								}, {
									name : 'show_name',
									mapping : 'show_name'
								}, {
									name : 'social_typename',
									mapping : 'social_typename'
								}, {
									name : 'start_month',
									mapping : 'start_month'
								}, {
									name : 'end_month',
									mapping : 'end_month'
								}, {
									name : 'add_start_month',
									mapping : 'add_start_month'
								}, {
									name : 'add_end_month',
									mapping : 'add_end_month'
								}, {
									name : 'add_pay_month',
									mapping : 'add_pay_month'
								}, {
									name : 'person_base_default',
									mapping : 'person_base_default'
								}, {
									name : 'person_percent_default',
									mapping : 'person_percent_default'
								}, {
									name : 'company_base_default',
									mapping : 'company_base_default'
								}, {
									name : 'company_percent_default',
									mapping : 'company_percent_default'
								}, {
									name : 'person_add',
									mapping : 'person_add'
								}, {
									name : 'company_add',
									mapping : 'company_add'
								}])
			});
	var dtdGrid = new Ext.grid.GridPanel({
				autoScroll : true,
				id : 'DTDGride',
				region : 'center',
				store : dtdstore,
				cm : dtdcm,
				loadMask : true,
				loadMask : {
					msg : '正在加载数据...'
				}
			});
	// 推荐模板页面-------------------------------------------------------------------------------------------------------------------------------
	var dtWindow = new Ext.Window({
				layout : 'border',
				x : 150,
				y : 150,
				width : 700,
				height : 500,
				title : '推荐模板查询',
				collapsible : true,
				minimizable : true,
				maximizable : true,
				constrain : true,
				plain : true,
				bufferResize : true,
				autoDestroy : 'hide',
				closeAction : 'hide',
				listeners : {
					minimize : function(w) {
						w.setPosition(0, 0);
						w.setSize(500, 400);
					}
				},
				items : [dtGrid, dtdGrid],
				buttons : [{
					text : '确定',
					id : 'save',
					handler : function() {
						fn_addItem(dtdGrid, dtdGrid.getStore().getRange(0,
										dtdGrid.getStore().getTotalCount()),
								dtWindow);
					}
				}, {
					text : '取消',
					id : 'cancel',
					handler : function() {
						dtWindow.hide();
					}
				}]
			});
	// 客户模板-------------------------------------------------------------------------------------------------------
	var ctsm = new Ext.grid.CheckboxSelectionModel();
	var ctcm = new Ext.grid.ColumnModel([new Ext.grid.RowNumberer(), ctsm, {
				header : '模板标识',
				width : 90,
				hidden : true,
				dataIndex : 'template_id'
			}, {
				header : '模板名称',
				width : 90,
				dataIndex : 'name'
			}, {
				header : '项数',
				width : 90,
				dataIndex : 'templateCount'
			}]);
	var ctstore = new Ext.data.Store({
				url : 'CsEmplsocialAction!queryCsSocialTemplateResult.action',
				reader : new Ext.data.JsonReader({
							root : 'csSocialResult.result',
							id : 'template_id',
							totalProperty : 'csSocialResult.totalCount'
						}, [{
									name : 'template_id',
									mapping : 'template_id'
								}, {
									name : 'name',
									mapping : 'name'
								}, {
									name : 'templateCount',
									mapping : 'templateCount'
								}])
			});
	var ctGrid = new Ext.grid.GridPanel({
				autoScroll : true,
				id : 'CTGride',
				region : 'north',
				height : 200,
				tbar : ['模板名称:', {
							xtype : 'textfield',
							id : 'ctname'
						}, {
							xtype : "tbseparator"
						}, {
							xtype : 'button',
							text : '模板查询',
							handler : function() {
								ctstore.on('beforeload', function() {
											ctstore.baseParams = {
												'filter.name' : Ext
														.getCmp('ctname')
														.getValue()
											}
										});
								ctstore.load();
							}
						}],
				bbar : new Ext.PagingToolbar({
							pageSize : pageSize,
							store : ctstore,
							displayInfo : true,
							dispalyMsg : '显示第{0}条到{1}条记录，一共{2}条',
							emptyMsg : '没有记录'
						}),
				cm : ctcm,
				selModel : new Ext.grid.RowSelectionModel({
							singleSelect : true
						}),
				store : ctstore,
				loadMask : true,
				loadMask : {
					msg : '正在加载数据...'
				}
			});
	ctGrid.addListener('rowclick', rowdblclickFn2);
	function rowdblclickFn2(grid, rowIndex, e) {
		var length = ctGrid.getSelectionModel().getSelections().length;
		if (length < 1) {
			return;
		} else {
			ctdstore.baseParams = {
				'filter.template_id' : ctGrid.getSelectionModel()
						.getSelections()[0].get('template_id')
			}
			ctdstore.load();
		}
	}
	// 客户模板细项--------------------------------------------------------------------------------------------------------------------------
	var ctdcm = new Ext.grid.ColumnModel([new Ext.grid.RowNumberer(), {
				header : '标识',
				width : 90,
				hidden : true,
				dataIndex : 'sub_social_security_id'
			}, {
				header : '社保项目标识',
				width : 90,
				hidden : true,
				dataIndex : 'social_security_id'
			}, {
				header : '所属类别标识',
				width : 90,
				hidden : true,
				dataIndex : 'social_typeid'
			}, {
				header : '社保项目名称',
				width : 90,
				dataIndex : 'show_name'
			}, {
				header : '所属类别',
				width : 90,
				dataIndex : 'social_typename'
			}, {
				header : '个人基数',
				width : 90,
				dataIndex : 'person_base_default'
			}, {
				header : '个人比例',
				width : 90,
				dataIndex : 'person_percent_default'
			}, {
				header : '企业基数',
				width : 90,
				dataIndex : 'company_base_default'
			}, {
				header : '企业比例',
				width : 90,
				dataIndex : 'company_percent_default'
			}]);
	var ctdstore = new Ext.data.Store({
				url : 'CsEmplsocialAction!queryCsSocialTemplateDetailsResult.action',
				reader : new Ext.data.JsonReader({
							root : 'csSocialList',
							id : 'sub_social_security_id'
						}, [{
									name : 'employee_ss_id',
									mapping : 'employee_ss_id'
								}, {
									name : 'sub_social_security_id',
									mapping : 'sub_social_security_id'
								}, {
									name : 'social_security_id',
									mapping : 'social_security_id'
								}, {
									name : 'social_typeid',
									mapping : 'social_typeid'
								}, {
									name : 'show_name',
									mapping : 'show_name'
								}, {
									name : 'social_typename',
									mapping : 'social_typename'
								}, {
									name : 'start_month',
									mapping : 'start_month'
								}, {
									name : 'end_month',
									mapping : 'end_month'
								}, {
									name : 'add_start_month',
									mapping : 'add_start_month'
								}, {
									name : 'add_end_month',
									mapping : 'add_end_month'
								}, {
									name : 'add_pay_month',
									mapping : 'add_pay_month'
								}, {
									name : 'person_base_default',
									mapping : 'person_base_default'
								}, {
									name : 'person_percent_default',
									mapping : 'person_percent_default'
								}, {
									name : 'company_base_default',
									mapping : 'company_base_default'
								}, {
									name : 'company_percent_default',
									mapping : 'company_percent_default'
								}, {
									name : 'person_add',
									mapping : 'person_add'
								}, {
									name : 'company_add',
									mapping : 'company_add'
								}])
			});
	var ctdGrid = new Ext.grid.GridPanel({
				autoScroll : true,
				id : 'CTDGride',
				region : 'center',
				store : ctdstore,
				cm : ctdcm,
				loadMask : true,
				loadMask : {
					msg : '正在加载数据...'
				}
			});
	// 客户模板页面-------------------------------------------------------------------------------------------------------------------------------
	var ctWindow = new Ext.Window({
				layout : 'border',
				x : 150,
				y : 150,
				width : 600,
				height : 500,
				title : '客户模板查询',
				collapsible : true,
				minimizable : true,
				maximizable : true,
				constrain : true,
				plain : true,
				bufferResize : true,
				autoDestroy : 'hide',
				closeAction : 'hide',
				listeners : {
					minimize : function(w) {
						w.setPosition(0, 0);
						w.setSize(500, 400);
					}
				},
				items : [ctGrid, ctdGrid],
				buttons : [{
					text : '确定',
					id : 'save',
					handler : function() {
						if (ctdGrid.getStore().getRange(0,
								ctdGrid.getStore().getTotalCount()) == "") {
							Ext.Msg.alert("警告", "请先查询后,双击查询结果以显示细项再点击确定按钮!");
						} else {
							fn_addItem(
									ctdGrid,
									ctdGrid.getStore().getRange(0,
											ctdGrid.getStore().getTotalCount()),
									ctWindow);
						}
					}
				}, {
					text : '取消',
					id : 'cancel',
					handler : function() {
						ctWindow.hide();
					}
				}]
			});
	// 新增员工社保档案----------------------------------------------------------------------------------------------------
	var employee_id_new = new Ext.form.Hidden({
				name : 'employee_id_new',
				id : 'employee_id_new'
			})
	var searchaddPanel = new Ext.form.FormPanel({
		frame : true,
		region : 'north',
		buttonAlign : 'right',
		title : "查询条件",
		id : 'searchaddPanel',
		height : 100,
		bodyStyle : 'padding:5px 5px 0',
		url : '',
		items : [{
			layout : 'column',
			items : [{
						columnWidth : .5,
						layout : 'form',
						items : [employee_id_new, {
									fieldLabel : '员工编号',
									anchor : '90%',
									id : 'empid_new',
									xtype : 'textfield',
									readOnly : true
								}]
					}, {
						columnWidth : .5,
						layout : 'form',
						items : [{
									fieldLabel : '员工姓名',
									anchor : '90%',
									id : 'empname_new',
									xtype : 'textfield',
									readOnly : true
								}]
					}],
			buttons : [{
						text : '员工查询',
						id : '_btnSearch',
						handler : function() {
							empWindow.show();
							Ext.getCmp('empid_new1').reset();
							Ext.getCmp('empname_new1').reset();
							empGrid.getStore().removeAll();
							empGrid.getSelectionModel().clearSelections(false);
						}
					}, {
						text : '增加细项',
						id : '_btninsert',
						handler : function() {
							iWindow.show();
						}
					}, {
						text : '删除细项',
						id : '_btnDelete',
						handler : function() {
							var rs = newGrid.getSelectionModel()
									.getSelections();
							var length = rs.length;
							if (length > 0) {
								Ext.MessageBox.show({
									title : '提示',
									msg : '您选中了' + length + '条记录进行删除,请问您确认吗?',
									buttons : Ext.MessageBox.OKCANCEL,
									fn : function(btn) {
										if (btn == "ok") {
											for (var i = 0; i < length; i++) {
												if (rs[i].data.employee_ss_id != "") {
													deletedJson
															.push(rs[i].data);
												}
												newstore.remove(newstore
														.getById(rs[i].id));
											};
										}
										if (btn == "cancel") {
											return;
										}
									}
								});
							} else {
								Ext.Msg.alert('警告', '请选择需要删除的记录.');
							}
						}
					}, {
						text : '客户模板',
						id : '_btninsert',
						handler : function() {
							ctWindow.show();
						}
					}, {
						text : '推荐模板',
						id : '_btninsert',
						handler : function() {
							dtWindow.show();
						}
					}, {
						text : '保存',
						id : '_btninsert',
						handler : function() {
							newGrid.stopEditing();
							if ($F("employee_id_new") == "") {
								Ext.Msg.alert("警告", "您未选择员工姓名！");
								return;
							}
							var addurl = 'CsEmplsocialAction!addEmpSocialI.action';
							var updurl = 'CsEmplsocialAction!updateCsEmpsocial.action';
							var _url = '';
							var paras = {};
							var add = [];
							if (updflag == true) {
								add = newstore.getRange(0,
										newGrid.getStore().getCount()).slice(0);
								_url = updurl;
							} else {
								add = newstore.getRange(0,
										newGrid.getStore().getCount()).slice(0);
								_url = addurl;
							}
							for (var i = 0; i < add.length; i++) {
								var record = add[i];
								var fields = record.fields.keys;
								for (var j = 4; j < fields.length - 2; j++) {
									var name = fields[j];
									var value = record.data[name];
									var colIndex = newcm.findColumnIndex(name);
									var rowIndex = newstore
											.indexOfId(record.id);
									var editor;
									if (typeof(newcm.getCellEditor(colIndex)) != 'undefined') {
										editor = newcm.getCellEditor(colIndex).field;
										if (name == 'start_month') {
											if (!checkDate(value, rowIndex,
													colIndex)) {
												return;
											}
										}
										if (name == 'end_month'
												&& value != null && value != '') {
											if (!checkDate(value, rowIndex,
													colIndex)) {
												return;
											}
											if (record.data[fields[j - 1]] > value) {
												Ext.MessageBox.alert('Error',
														'终止月必须大于起始月！',
														function() {
															newGrid
																	.startEditing(
																			rowIndex,
																			newcm
																					.findColumnIndex('end_month'));
														});
												return;
											}
										}
										if (name == 'add_start_month'
												&& value != null && value != '') {
											if (!checkDate(value, rowIndex,
													colIndex)) {
												return;
											}
											if (!checkDate(record.data[fields[j
															+ 1]], rowIndex,
													colIndex + 1)) {
												return;
											}
											if (value > record.data[fields[j
													+ 1]]) {
												Ext.MessageBox.alert('Error',
														'补缴终止月必须大于起始月！',
														function() {
															newGrid
																	.startEditing(
																			rowIndex,
																			colIndex
																					+ 1);
														});
												return;
											}
											if (!checkDate(record.data[fields[j
															+ 2]], rowIndex,
													colIndex + 2)) {
												return;
											}
										}
										if (value != null
												&& !editor.validateValue(value)) {
											Ext.Msg.alert('提示', '输入的数据不正确！',
													function() {
														newGrid.startEditing(
																rowIndex,
																colIndex);
													});
											return;
										}
									}
								}

							}
							var addArray = [];
							Ext.each(add, function(item) {
										addArray.push(item.data);
									});
							paras.adds = Ext.encode(addArray);
							paras.deleted = Ext.encode(deletedJson);
							paras.emp_code = Ext.getCmp('employee_id_new')
									.getValue();
							Ext.Ajax.request({
										url : _url,
										method : 'post',
										params : paras,
										success : function() {
											deletedJson = [];
											newWindow.hide();
											Ext.Msg.show({
														title : '操作信息',
														msg : '数据处理成功',
														buttons : Ext.Msg.OK
													});
											socialstore.load();
										},
										failure : function() {
											deletedJson = [];
											newWindow.hide();
											Ext.Msg.show({
														title : '操作信息',
														msg : '数据处理异常,请联系管理员',
														buttons : Ext.Msg.OK
													});
										}
									});
						}
					}, {
						text : '不计入结果',
						id : 'BJRJG',
						handler : function() {
							fn_bjrjg();
						}
					}, {
						text : '取消',
						id : '_btninsert',
						handler : function() {
							newWindow.hide();
						}
					}]
		}]
	});

	var newsm = new Ext.grid.CheckboxSelectionModel();
	var newcm = new Ext.grid.ColumnModel([new Ext.grid.RowNumberer(), newsm, {
				header : '标识employee_ss_id',
				width : 90,
				hidden : true,
				dataIndex : 'employee_ss_id'
			}, {
				header : '社保项目标识',
				width : 90,
				hidden : true,
				dataIndex : 'social_security_id'
			}, {
				header : '社保项目名称',
				width : 90,
				dataIndex : 'show_name'
			}, {
				header : '所属类别',
				width : 90,
				dataIndex : 'social_typename'
			}, {
				header : '起始月',
				width : 90,
				dataIndex : 'start_month',
				editor : new Ext.form.TextField({})
			}, {
				header : '终止月',
				width : 90,
				dataIndex : 'end_month',
				editor : new Ext.form.TextField({})
			}, {
				header : '补缴起始月',
				width : 90,
				dataIndex : 'add_start_month',
				editor : new Ext.form.TextField({})
			}, {
				header : '补缴终止月',
				width : 90,
				dataIndex : 'add_end_month',
				editor : new Ext.form.TextField({})
			}, {
				header : '实作月',
				width : 90,
				dataIndex : 'add_pay_month',
				editor : new Ext.form.TextField({})
			}, {
				header : '个人基数',
				width : 90,
				dataIndex : 'person_base_default',
				editor : new Ext.form.NumberField({
							allowBlank : false,
							allowNegative : false,
							decimalPrecision : 2
						})
			}, {
				header : '企业基数',
				width : 90,
				dataIndex : 'company_base_default',
				editor : new Ext.form.NumberField({
							allowBlank : false,
							allowNegative : false,
							decimalPrecision : 2
						})
			}, {
				header : '个人比例',
				width : 90,
				dataIndex : 'person_percent_default',
				editor : new Ext.form.NumberField({// 与项目比较
					allowBlank : false,
					allowNegative : false,
					decimalPrecision : 4
				})
			}, {
				header : '企业比例',
				width : 90,
				dataIndex : 'company_percent_default',
				editor : new Ext.form.NumberField({// 与项目比较
					allowBlank : false,
					allowNegative : false,
					decimalPrecision : 4
				})
			}]);
	var reader = new Ext.data.JsonReader({
				root : 'csEmplsocialResult.result',
				id : 'employee_ss_id',
				totalProperty : 'csEmplsocialResult.totalCount'
			}, [{
						name : 'employee_ss_id',
						mapping : 'employee_ss_id'
					}, {
						name : 'sub_social_security_id',
						mapping : 'sub_social_security_id'
					}, {
						name : 'social_security_id',
						mapping : 'social_security_id'
					}, {
						name : 'social_typeid',
						mapping : 'social_typeid'
					}, {
						name : 'show_name',
						mapping : 'show_name'
					}, {
						name : 'social_typename',
						mapping : 'social_typename'
					}, {
						name : 'start_month',
						mapping : 'start_month'
					}, {
						name : 'end_month',
						mapping : 'end_month'
					}, {
						name : 'add_start_month',
						mapping : 'add_start_month'
					}, {
						name : 'add_end_month',
						mapping : 'add_end_month'
					}, {
						name : 'add_pay_month',
						mapping : 'add_pay_month'
					}, {
						name : 'person_base_default',
						mapping : 'person_base_default'
					}, {
						name : 'company_base_default',
						mapping : 'company_base_default'
					}, {
						name : 'person_percent_default',
						mapping : 'person_percent_default'
					}, {
						name : 'company_percent_default',
						mapping : 'company_percent_default'
					}, {
						name : 'person_add',
						mapping : 'person_add'
					}, {
						name : 'company_add',
						mapping : 'company_add'
					}])
	var newstore = new Ext.data.Store({
				pruneModifiedRecords : true,
				url : 'CsEmplsocialAction!querycsEmplsocialDetails.action',
				reader : reader,
				listeners : {
					'update' : function(thiz, record, operation) {
						var csEmplsocial = thiz.getAt(thiz.indexOf(record)).data;
						var rowIndex = thiz.indexOf(record);
						var colIndex = '';
					}
				}
			});
	// 新增员工社保-------------------------------------------------------------------------------------------------------------------------------------

	var newGrid = new Ext.grid.EditorGridPanel({
				autoScroll : true,
				id : 'TGride',
				region : 'center',
				bbar : new Ext.PagingToolbar({
							pageSize : pageSize,
							store : newstore,
							displayInfo : true,
							dispalyMsg : '显示第{0}条到{1}条记录，一共{2}条',
							emptyMsg : '没有记录'
						}),
				sm : newsm,
				cm : newcm,
				clicksToEdit : 1,
				store : newstore,
				loadMask : true,
				loadMask : {
					msg : '正在加载数据...'
				}
			});
	var newWindow = new Ext.Window({
				layout : 'border',
				x : 100,
				y : 100,
				width : 800,
				height : 500,
				title : '员工社保维护',
				collapsible : true,
				minimizable : true,
				maximizable : true,
				constrain : true,
				plain : true,
				bufferResize : true,
				autoDestroy : 'hide',
				closeAction : 'hide',
				listeners : {
					minimize : function(w) {
						w.setPosition(0, 0);
						w.setSize(500, 400);
					},
					hide : function() {
						fn_gridTextReset();
					}
				},
				items : [searchaddPanel, newGrid]
			});
	// 已有社保员工----------------------------------------------------------------------------------------------------
	var searchPanel = new Ext.form.FormPanel({
		frame : true,
		buttonAlign : 'right',
		title : "查询条件",
		id : 'employMessage',
		bodyStyle : 'padding:5px 5px 0',
		url : '',
		items : [{
			layout : 'column',
			items : [{
						columnWidth : .5,
						layout : 'form',
						items : [{
									fieldLabel : '员工编号',
									anchor : '90%',
									id : 'empid',
									xtype : 'textfield'
								}]
					}, {
						columnWidth : .5,
						layout : 'form',
						items : [{
									fieldLabel : '员工姓名',
									anchor : '90%',
									id : 'empname',
									xtype : 'textfield'
								}]
					}],
			buttons : [{
				text : '查询',
				id : '_btnSearch',
				handler : function() {
					socialstore.on('beforeload', function() {
						socialstore.baseParams = {
							'filter.empCsCode' : Ext.getCmp('empid').getValue(),
							'filter.name' : Ext.getCmp('empname').getValue()
						}
					});
					socialstore.load();
				}
			}, {
				text : '新增',
				id : '_btninsert',
				handler : function() {
					updflag = false;
					newstore.removeAll();
					newstore.on('beforeload', function() {
								newstore.baseParams = {
									'filter.employee_id' : '--'
								}
							})
					newWindow.show();
					Ext.getCmp('empid_new').reset();
					Ext.getCmp('empname_new').reset();
				}
			}, {
				text : '根据社保项目调整社保',
				id : '_btnDelete',
				handler : function() {
					adjustWindow.show();
					socialTypeMasterStore.proxy = new Ext.data.HttpProxy({
								url : "socialItem!findSocialItemByCompanCode.action"
							});
					socialTypeMasterStore.load();
					Ext.getCmp('_btnAdd').hide();
					Ext.getCmp('_btnDel').hide();
				}
			}, {
				text : '根据员工调整社保',
				id : '_btnDelete',
				handler : function() {
					adjustWindow2.show();
				}
			}]
		}]
	});

	searchPanel.render(Ext.getBody());
	var cm = new Ext.grid.ColumnModel([new Ext.grid.RowNumberer(), {
				header : '标识',
				hidden : true,
				dataIndex : 'employee_ss_id'
			}, {
				header : '员工标识',
				hidden : true,
				dataIndex : 'employee_id'
			}, {
				header : '员工编号',
				dataIndex : 'empCsCode11'
			}, {
				header : '员工名称',
				dataIndex : 'name'
			}, {
				header : '社保项数',
				dataIndex : 'count'
			}/*
				 * , { header : '操作', dataIndex : 'status', width : 100,
				 * renderer : function(v, p, record) { return "<input
				 * type='button' class='x-btn' value='详细信息'
				 * onClick=\"InsertManager("+ record.data.employee_ss_id+ "
				 * ')\">"; } }
				 */]);
	socialstore = new Ext.data.Store({
				url : 'CsEmplsocialAction!querycsEmplsocials.action',
				reader : new Ext.data.JsonReader({
							root : 'csEmplsocialResult.result',
							id : 'employee_ss_id',
							totalProperty : 'csEmplsocialResult.totalCount'
						}, [{
									name : 'employee_ss_id',
									mapping : 'employee_ss_id'
								}, {
									name : 'employee_id',
									mapping : 'employee_id'
								}, {
									name : 'empCsCode11',
									mapping : 'emp_cs_code'
								}, {
									name : 'name',
									mapping : 'name'
								}, {
									name : 'count',
									mapping : 'count'
								}])
			});
	var socialGrid = new Ext.grid.GridPanel({// searchPanel
		title : '员工社保',
		trackMouseOver : true,
		stripeRows : true,
		autoScroll : true,
		hideCollapseTool : true,
		selModel : new Ext.grid.RowSelectionModel({
					singleSelect : false
				}),
		collapsible : true,
		titleCollapse : true,
		frame : true,
		bufferResize : true,
		loadMask : true,
		id : 'socialGrid',
		height : document.body.clientHeight - searchPanel.getInnerHeight()
				- searchPanel.getFrameHeight(),
		bbar : new Ext.PagingToolbar({
					pageSize : pageSize,
					store : socialstore,
					displayInfo : true,
					dispalyMsg : '显示第{0}条到{1}条记录，一共{2}条',
					emptyMsg : '没有记录'
				}),
		cm : cm,
		store : socialstore,
		loadMask : true,
		loadMask : {
			msg : '正在加载数据...'
		}
	});
	// 社保档案调整

	function rowdblclickFn(grid, rowIndex, e) {
		record = grid.getStore().getAt(rowIndex);
		updflag = true;
		newstore.on('beforeload', function() {
					newstore.baseParams = {
						'filter.employee_id' : record.get('employee_id')
					}
				});
		newstore.load();
		newWindow.show();
		$("employee_id_new").value = record.get('employee_id');
		$("empname_new").value = record.get('name');
		$("empid_new").value = record.get('empCsCode11');
	}
	socialstore.load();
	socialGrid.addListener('rowdblclick', rowdblclickFn);
	socialGrid.render(Ext.getBody());
	/**
	 * 目标：设定is_valid＝－1 如果该社保项目之前计算过，需要进行提示，由使用者选择是或者否，
	 * "如果不计入结果，之前计算过的内容不会被重算，如果需要重算， 进行时间段分拆"，是，则设定is_valid＝-1，否，返回之前的页面；
	 * 如果终止月为空，使用者选择是，把当前月份写入终止月(YYYYMM)
	 */
	function fn_bjrjg() {
		var rs = newGrid.getSelectionModel().getSelections();
		var length = rs.length;
		if (length > 0) {
			Ext.MessageBox.show({
				title : '提示',
				msg : '您选中了' + length + '条记录进行不计入结果操作,请问您确认吗?',
				buttons : Ext.MessageBox.OKCANCEL,
				fn : function(btn) {
					if (btn == "ok") {
						var arrs = [], new_arrs = [], delid_arrs = [];
						for (var i = 0; i < length; i++) {
							if (rs[i].data.employee_ss_id == "") {
								new_arrs.push(rs[i].data.show_name);
							}
							arrs.push(rs[i].data.social_security_id);
							delid_arrs.push(newstore.getById(rs[i].id));
						};

						if (new_arrs.length != 0) {
							Ext.Msg.alert("警告", "社保项目：" + new_arrs.join(',')
											+ "，没有保存，请确认！");
							return;
						} else {
							Ext.Ajax.request({
								url : "CsEmplsocialAction!checkEmpSSocialItemIsCaled.action",
								method : 'post',
								params : {
									'csEmplsocial.ids' : arrs.join(','),
									'csEmplsocial.employee_id' : $F("employee_id_new")
								},
								success : function(response) {
									var responseTextVale = Ext.util.JSON
											.decode(response.responseText);
									if (responseTextVale.msg == "") {
										Ext.Ajax.request({
											url : "CsEmplsocialAction!bjrjg.action",
											method : 'post',
											params : {
												'csEmplsocial.ids' : arrs
														.join(','),
												'csEmplsocial.employee_id' : $F("employee_id_new")
											},
											success : function(response) {
												Ext.Msg.alert('警告', '操作成功！');
												for (var i = 0; i < delid_arrs.length; i++) {
													newstore
															.remove(delid_arrs[i]);
												}
												socialstore.on('beforeload',
														function() {
															socialstore.baseParams = {
																'filter.empCsCode' : Ext
																		.getCmp('empid')
																		.getValue(),
																'filter.name' : Ext
																		.getCmp('empname')
																		.getValue()
															}
														});
												socialstore.load();
											},
											failure : function() {
												Ext.Msg.alert('警告', '操作异常！');
											}
										});
									} else {
										Ext.MessageBox.show({
											title : '警告',
											msg : responseTextVale.msg,
											buttons : Ext.MessageBox.OKCANCEL,
											fn : function(btn) {
												if (btn == "ok") {
													Ext.Ajax.request({
														url : "CsEmplsocialAction!bjrjg.action",
														method : 'post',
														params : {
															'csEmplsocial.ids' : arrs
																	.join(','),
															'csEmplsocial.employee_id' : $F("employee_id_new")
														},
														success : function(
																response) {
															Ext.Msg.alert('警告',
																	'操作成功！');
															for (var i = 0; i < delid_arrs.length; i++) {
																newstore
																		.remove(delid_arrs[i]);
															}
															socialstore
																	.on(
																			'beforeload',
																			function() {
																				socialstore.baseParams = {
																					'filter.empCsCode' : Ext
																							.getCmp('empid')
																							.getValue(),
																					'filter.name' : Ext
																							.getCmp('empname')
																							.getValue()
																				}
																			});
															socialstore.load();
														},
														failure : function() {
															Ext.Msg.alert('警告',
																	'操作异常！');
														}
													});
												} else {
													return;
												}
											}
										});
									}
								},
								failure : function() {
									Ext.Msg.alert('警告', '操作异常！');
								}
							});
						}
					}
					if (btn == "cancel") {
						return;
					}
				}
			});
		} else {
			Ext.Msg.alert('警告', '请选择需要不计入结果的记录！');
			return;
		}
	}
});
function $(id) {
	return document.getElementById(id);
}
function $F(id) {
	return $(id).value;
}
